{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [更多资源](03.13-Further-Resources.ipynb) | [目录](Index.ipynb) | [简单的折线图](04.01-Simple-Line-Plots.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/04.00-Introduction-To-Matplotlib.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization with Matplotlib\n",
    "\n",
    "# 使用Matplotlib进行可视化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We'll now take an in-depth look at the Matplotlib package for visualization in Python.\n",
    "Matplotlib is a multi-platform data visualization library built on NumPy arrays, and designed to work with the broader SciPy stack.\n",
    "It was conceived by John Hunter in 2002, originally as a patch to IPython for enabling interactive MATLAB-style plotting via gnuplot from the IPython command line.\n",
    "IPython's creator, Fernando Perez, was at the time scrambling to finish his PhD, and let John know he wouldn’t have time to review the patch for several months.\n",
    "John took this as a cue to set out on his own, and the Matplotlib package was born, with version 0.1 released in 2003.\n",
    "It received an early boost when it was adopted as the plotting package of choice of the Space Telescope Science Institute (the folks behind the Hubble Telescope), which financially supported Matplotlib’s development and greatly expanded its capabilities.\n",
    "\n",
    "本章中我们会介绍在Python中使用Matplotlib包进行可视化的知识。Matplotlib是一个基于NumPy数组构建的多平台数据可视化程序库，在SciPy技术栈中被广泛使用。Matplotlib是John Hunter在2002年开始构思，最早时候是作为IPython的一个补充，通过gnuplot用来在IPython命令行中实现MATLAB风格的交互式的图表展示。IPython的作者Fernando Perez那时正在忙于完成他的博士学位，John意识到他可能在几个月内都无法抽出时间来检查这个补丁的代码。于是John决定将这个构思实现成独立的软件包，于是MatPlotlib诞生了，0.1版本发布于2003年。最早时候在空间望远镜研究院（也就是哈勃望远镜背后的工作小组）得到应用来绘图，从中获得了很大的推动力，研究院从经济上支持Matplotlib项目的发展并极大的扩展了其功能。\n",
    "\n",
    "> One of Matplotlib’s most important features is its ability to play well with many operating systems and graphics backends.\n",
    "Matplotlib supports dozens of backends and output types, which means you can count on it to work regardless of which operating system you are using or which output format you wish.\n",
    "This cross-platform, everything-to-everyone approach has been one of the great strengths of Matplotlib.\n",
    "It has led to a large user base, which in turn has led to an active developer base and Matplotlib’s powerful tools and ubiquity within the scientific Python world.\n",
    "\n",
    "Matplotlib最重要的特性之一就是它的对很多操作系统以及后端图形引擎的广泛支持。Matplotlib能在大量的图形引擎上工作并输出多种不同的格式，这意味着你可以认为无论使用哪种操作系统输出哪种格式，它都能良好工作。这种特性为Matplotlib带来了大量的用户基础，从而也吸引了活跃的开发者社区，使其发展称为在整个科学Python社区中无处不在的强大绘图工具。\n",
    "\n",
    "> In recent years, however, the interface and style of Matplotlib have begun to show their age.\n",
    "Newer tools like ggplot and ggvis in the R language, along with web visualization toolkits based on D3js and HTML5 canvas, often make Matplotlib feel clunky and old-fashioned.\n",
    "Still, I'm of the opinion that we cannot ignore Matplotlib's strength as a well-tested, cross-platform graphics engine.\n",
    "Recent Matplotlib versions make it relatively easy to set new global plotting styles (see [Customizing Matplotlib: Configurations and Style Sheets](04.11-Settings-and-Stylesheets.ipynb)), and people have been developing new packages that build on its powerful internals to drive Matplotlib via cleaner, more modern APIs—for example, Seaborn (discussed in [Visualization With Seaborn](04.14-Visualization-With-Seaborn.ipynb)), [ggpy](http://yhat.github.io/ggpy/), [HoloViews](http://holoviews.org/), [Altair](http://altair-viz.github.io/), and even Pandas itself can be used as wrappers around Matplotlib's API.\n",
    "Even with wrappers like these, it is still often useful to dive into Matplotlib's syntax to adjust the final plot output.\n",
    "For this reason, I believe that Matplotlib itself will remain a vital piece of the data visualization stack, even if new tools mean the community gradually moves away from using the Matplotlib API directly.\n",
    "\n",
    "然而最近几年，Matplotlib显得有点过时了。R语言中的ggplot和ggvis这些新工具广泛应用了类似D3js和HTML5画布这样的Web技术，让Matplotlib显得相形见绌。近来的Matplotlib版本将设置新的图表风格变得相对简单了一些（参见[自定义matplotlib：配置和样式单](04.11-Settings-and-Stylesheets.ipynb)），而且开发者在Matplotlib基础上开发了很多新的包，使得可视化过程能够通过更清晰和现代的API来实现，例如Seaborn（参见[使用Seaborn进行可视化](04.14-Visualization-With-Seaborn.ipynb)）、[ggpy](http://yhat.github.io/ggpy/)、[HoloViews](http://holoviews.org/)和[Altair](http://altair-viz.github.io/)，而且Pandas本身也提供了对Matplotlib的API封装。但是即使使用封装后的API，深入研究Matplotlib的语法对于更精细的调整图表的输出也是非常有帮助的。正因为如此，作者深信Matplotlib仍然会在数据可视化技术栈中占有不可或缺的地位，即使近期，社区已经逐步不再直接调用Matplotlib的API的情况下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General Matplotlib Tips\n",
    "\n",
    "## 通用提示\n",
    "\n",
    "> Before we dive into the details of creating visualizations with Matplotlib, there are a few useful things you should know about using the package.\n",
    "\n",
    "在我们开始深入介绍使用Matplotlib进行可视化之前，有一些使用该软件包的基本知识需要了解。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing Matplotlib\n",
    "\n",
    "### 载入Matplotlib\n",
    "\n",
    "> Just as we use the ``np`` shorthand for NumPy and the ``pd`` shorthand for Pandas, we will use some standard shorthands for Matplotlib imports:\n",
    "\n",
    "NumPy的载入使用惯例别名`np`，Pandas的载入使用惯例别名`pd`，下面是载入Matplotlib的惯例别名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The ``plt`` interface is what we will use most often, as we shall see throughout this chapter.\n",
    "\n",
    "`plt`是我们最常用的模块，本章中我们会一直看到它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting Styles\n",
    "\n",
    "### 设置风格\n",
    "\n",
    "> We will use the ``plt.style`` directive to choose appropriate aesthetic styles for our figures.\n",
    "Here we will set the ``classic`` style, which ensures that the plots we create use the classic Matplotlib style:\n",
    "\n",
    "使用`plt.style`属性用来给我们的图表设置视觉的风格。下面我们设置使用`classic`风格，这让我们之后的图表都会保持使用经典Matplotlib风格："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('classic')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Throughout this section, we will adjust this style as needed.\n",
    "Note that the stylesheets used here are supported as of Matplotlib version 1.5; if you are using an earlier version of Matplotlib, only the default style is available.\n",
    "For more information on stylesheets, see [Customizing Matplotlib: Configurations and Style Sheets](04.11-Settings-and-Stylesheets.ipynb).\n",
    "\n",
    "在本章中，我们会根据需要调整风格设置。这里要说明的是，只有Matplotlib 1.5及之后的版本支持风格设置；如果你在使用更早期的版本，那么Matplotlib只能使用默认风格。要获取关于样式单的更多内容，参见[自定义matplotlib：配置和样式单](04.11-Settings-and-Stylesheets.ipynb)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ``show()`` or No ``show()``? How to Display Your Plots\n",
    "\n",
    "### `show()` 或是不要 `show()` ？如何显示你的图表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> A visualization you can't see won't be of much use, but just how you view your Matplotlib plots depends on the context.\n",
    "The best use of Matplotlib differs depending on how you are using it; roughly, the three applicable contexts are using Matplotlib in a script, in an IPython terminal, or in an IPython notebook.\n",
    "\n",
    "一张你看不到的图表不会有什么用处，但是显示图表的方法根据使用环境会有所不同。Matplotlib的最佳实践取决于你在什么环境中使用它；通常有三种应用场景，在脚本文件中使用，在IPython终端中使用以及在IPython notebook中使用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting from a script\n",
    "\n",
    "#### 在脚本文件中作图\n",
    "\n",
    "> If you are using Matplotlib from within a script, the function ``plt.show()`` is your friend.\n",
    "``plt.show()`` starts an event loop, looks for all currently active figure objects, and opens one or more interactive windows that display your figure or figures.\n",
    "\n",
    "如果你是在脚本文件中使用Matplotlib，`plt.show()`是你显示图表的函数。`plt.show()`会启动一个事件循环，找到所有激活的图表对象，然后打开一个或多个交互的窗口来显示你的图表。\n",
    "\n",
    "> So, for example, you may have a file called *myplot.py* containing the following:\n",
    "\n",
    "因此，假设你有一个*myplot.py*文件包含以下代码：\n",
    "\n",
    "```python\n",
    "# ------- file: myplot.py ------\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "x = np.linspace(0, 10, 100)\n",
    "\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.plot(x, np.cos(x))\n",
    "\n",
    "plt.show()\n",
    "```\n",
    "\n",
    "> You can then run this script from the command-line prompt, which will result in a window opening with your figure displayed:\n",
    "\n",
    "你可以在命令行中运行这个脚本文件，运行结果会打开一个窗口里面显示你设置的图表：\n",
    "\n",
    "```bash\n",
    "$ python myplot.py\n",
    "```\n",
    "\n",
    "> The ``plt.show()`` command does a lot under the hood, as it must interact with your system's interactive graphical backend.\n",
    "The details of this operation can vary greatly from system to system and even installation to installation, but matplotlib does its best to hide all these details from you.\n",
    "\n",
    "`plt.show()`函数在底层做了许多工作，因为它需要和你系统的交互式图形引擎通信。这个操作的细节根据系统不同甚至不同安装方式会有区别，Matplotlib尽最大可能为用户屏蔽了这些底层实现细节。\n",
    "\n",
    "> One thing to be aware of: the ``plt.show()`` command should be used *only once* per Python session, and is most often seen at the very end of the script.\n",
    "Multiple ``show()`` commands can lead to unpredictable backend-dependent behavior, and should mostly be avoided.\n",
    "\n",
    "还要提醒一下：`plt.show()`函数在每个Python会话中*仅能使用一次*，最常见的情况就是在脚本的末尾使用它。多次调用`show()`函数会导致不可预料的结果，应该避免。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting from an IPython shell\n",
    "\n",
    "#### 在IPython终端中作图\n",
    "\n",
    "> It can be very convenient to use Matplotlib interactively within an IPython shell (see [IPython: Beyond Normal Python](01.00-IPython-Beyond-Normal-Python.ipynb)).\n",
    "IPython is built to work well with Matplotlib if you specify Matplotlib mode.\n",
    "To enable this mode, you can use the ``%matplotlib`` magic command after starting ``ipython``:\n",
    "\n",
    "在IPython终端（参见[IPython：超越Python解释器](01.00-IPython-Beyond-Normal-Python.ipynb)）中交互式使用Matplotlib是非常方便的。IPython内建有支持Matplotlib的模式。要激活这个模式，你只需要在IPython终端输入`%matplotlib`魔术指令即可：\n",
    "\n",
    "```python\n",
    "In [1]: %matplotlib\n",
    "Using matplotlib backend: TkAgg\n",
    "\n",
    "In [2]: import matplotlib.pyplot as plt\n",
    "```\n",
    "\n",
    "> At this point, any ``plt`` plot command will cause a figure window to open, and further commands can be run to update the plot.\n",
    "Some changes (such as modifying properties of lines that are already drawn) will not draw automatically: to force an update, use ``plt.draw()``.\n",
    "Using ``plt.show()`` in Matplotlib mode is not required.\n",
    "\n",
    "这之后任何`plt`的作图命令都会打开一个窗口包含作出的图表，后续运行的命令还能更新图表。某些改变（例如修改已经画好的线条的属性）不会自动更新，这时可以使用`plt.draw()`来强制更新窗口。在Matplotlib模式下是不需要使用`plt.show()`的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting from an IPython notebook\n",
    "\n",
    "#### 在IPython notebook中作图\n",
    "\n",
    "> The IPython notebook is a browser-based interactive data analysis tool that can combine narrative, code, graphics, HTML elements, and much more into a single executable document (see [IPython: Beyond Normal Python](01.00-IPython-Beyond-Normal-Python.ipynb)).\n",
    "\n",
    "IPython notebook是一个基于浏览器的交互式开发工具，能将说明、代码、图像、HTML和其他内容都合成在一个可执行文档中（参见[IPython：超越Python解释器](01.00-IPython-Beyond-Normal-Python.ipynb)）。\n",
    "\n",
    "> Plotting interactively within an IPython notebook can be done with the ``%matplotlib`` command, and works in a similar way to the IPython shell.\n",
    "In the IPython notebook, you also have the option of embedding graphics directly in the notebook, with two possible options:\n",
    "\n",
    "> - ``%matplotlib notebook`` will lead to *interactive* plots embedded within the notebook\n",
    "> - ``%matplotlib inline`` will lead to *static* images of your plot embedded in the notebook\n",
    "\n",
    "在IPython notebook中交互式的作图也可以使用`%matplotlib`魔术指令，其工作方式类似于在IPython终端中一样。而且在IPython notebook中，你还可以通过指定该魔术指令的参数让作出的图直接在内联在notebook中显示。两个参数可以指定不同的作图模式：\n",
    "\n",
    "- `%matplotlib notebook`：在notebook中作出具有交互控制功能的内联图表\n",
    "- `%matplotlib inline`： 在notebook中作出*静态*内联图表\n",
    "\n",
    "> For this book, we will generally opt for ``%matplotlib inline``:\n",
    "\n",
    "本书中，我们通常使用`%matplotlib inline`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> After running this command (it needs to be done only once per kernel/session), any cell within the notebook that creates a plot will embed a PNG image of the resulting graphic:\n",
    "\n",
    "运行了这条魔术指令后（只需要在每个jupyter内核中运行一次即可），后续notebook中任何创建图表的代码都会输出一个内嵌的PNG图像，作出图表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.linspace(0, 10, 100)\n",
    "\n",
    "fig = plt.figure()\n",
    "plt.plot(x, np.sin(x), '-')\n",
    "plt.plot(x, np.cos(x), '--');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving Figures to File\n",
    "\n",
    "### 将图表保存到文件\n",
    "\n",
    "> One nice feature of Matplotlib is the ability to save figures in a wide variety of formats.\n",
    "Saving a figure can be done using the ``savefig()`` command.\n",
    "For example, to save the previous figure as a PNG file, you can run this:\n",
    "\n",
    "Matplotlib还有一个非常棒的功能，那就是将图表保存成很多种不同的文件格式。保存图表可以通过`savefig()`函数实现。例如，如果我们需要将上面的图表保存成一个PNG文件，只需要执行下面的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig('my_figure.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We now have a file called ``my_figure.png`` in the current working directory:\n",
    "\n",
    "然后在当前工作目录下就可以看到这个文件："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-rw-r-- 1 wangy wangy 26K 12月  6 15:47 my_figure.png\r\n"
     ]
    }
   ],
   "source": [
    "!ls -lh my_figure.png"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> To confirm that it contains what we think it contains, let's use the IPython ``Image`` object to display the contents of this file:\n",
    "\n",
    "我们可以使用IPython的`Image`对象将这个图像文件显示出来，验证一下保存的文件是否和图表一致："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image('my_figure.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> In ``savefig()``, the file format is inferred from the extension of the given filename.\n",
    "Depending on what backends you have installed, many different file formats are available.\n",
    "The list of supported file types can be found for your system by using the following method of the figure canvas object:\n",
    "\n",
    "在`savefig()`函数中，保存文件的格式是通过文件的扩展名决定的。根据系统的图形引擎不同，支持的文件格式略有不同。你可以通过下面的代码列出系统支持的所有文件格式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ps': 'Postscript',\n",
       " 'eps': 'Encapsulated Postscript',\n",
       " 'pdf': 'Portable Document Format',\n",
       " 'pgf': 'PGF code for LaTeX',\n",
       " 'png': 'Portable Network Graphics',\n",
       " 'raw': 'Raw RGBA bitmap',\n",
       " 'rgba': 'Raw RGBA bitmap',\n",
       " 'svg': 'Scalable Vector Graphics',\n",
       " 'svgz': 'Scalable Vector Graphics',\n",
       " 'jpg': 'Joint Photographic Experts Group',\n",
       " 'jpeg': 'Joint Photographic Experts Group',\n",
       " 'tif': 'Tagged Image File Format',\n",
       " 'tiff': 'Tagged Image File Format'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig.canvas.get_supported_filetypes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note that when saving your figure, it's not necessary to use ``plt.show()`` or related commands discussed earlier.\n",
    "\n",
    "注意当你保存图表的时候，是不需要使用`plt.show()`或类似的显示图表命令的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two Interfaces for the Price of One\n",
    "\n",
    "## 两套不同接口\n",
    "\n",
    "> A potentially confusing feature of Matplotlib is its dual interfaces: a convenient MATLAB-style state-based interface, and a more powerful object-oriented interface. We'll quickly highlight the differences between the two here.\n",
    "\n",
    "Matplotlib一个很令人迷惑的地方是它具有两套接口：一套是很方便的MATLAB风格的接口，还有一套是更强大的面向对象的接口。我们在这里简单的介绍一下它们的区别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### MATLAB-style Interface\n",
    "\n",
    "#### MATLAB 风格接口\n",
    "\n",
    "> Matplotlib was originally written as a Python alternative for MATLAB users, and much of its syntax reflects that fact.\n",
    "The MATLAB-style tools are contained in the pyplot (``plt``) interface.\n",
    "For example, the following code will probably look quite familiar to MATLAB users:\n",
    "\n",
    "Matplotlib最早是用来为MATLAB用户提供一套Python环境下的替代品，因此很多的语法反映了这一点。MATLAB风格的接口（函数）都封装在pyplot（`plt`）模块中。例如，下面的代码对于MATLAB用户来说不会陌生："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()  # 创建图表\n",
    "\n",
    "# 创建上面第一行的子图表，并设置x，y轴的数据\n",
    "plt.subplot(2, 1, 1) # (行、列、子图表序号)\n",
    "plt.plot(x, np.sin(x))\n",
    "\n",
    "# 创建下面第二行的子图表，并设置x，y轴的数据\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x, np.cos(x));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> It is important to note that this interface is *stateful*: it keeps track of the \"current\" figure and axes, which are where all ``plt`` commands are applied.\n",
    "You can get a reference to these using the ``plt.gcf()`` (get current figure) and ``plt.gca()`` (get current axes) routines.\n",
    "\n",
    "需要提醒的是这套接口是*有状态*的：它会持续保持着*当前的*图表和维度，无论那个`plt`命令改变了它。你可以通过`glt.gcf()`和`plt.gca()`函数获得图表和维度的引用。\n",
    "\n",
    "> While this stateful interface is fast and convenient for simple plots, it is easy to run into problems.\n",
    "For example, once the second panel is created, how can we go back and add something to the first?\n",
    "This is possible within the MATLAB-style interface, but a bit clunky.\n",
    "Fortunately, there is a better way.\n",
    "\n",
    "虽然这种有状态的接口在创建简单图表时非常快速和方便，但是也存在问题。例如，当第二个子图表创建了之后，我们如何回去在第一个子图表中增加内容呢？虽然在MATLAB风格接口中也可以实现，但是非常别扭。幸运的是，我们有更好的办法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Object-oriented interface\n",
    "\n",
    "#### 面向对象接口\n",
    "\n",
    "> The object-oriented interface is available for these more complicated situations, and for when you want more control over your figure.\n",
    "Rather than depending on some notion of an \"active\" figure or axes, in the object-oriented interface the plotting functions are *methods* of explicit ``Figure`` and ``Axes`` objects.\n",
    "To re-create the previous plot using this style of plotting, you might do the following:\n",
    "\n",
    "面向对象接口更适合于这种复杂的场景和你需要对图表更多控制权的场景。与其依赖于“当前活跃的”图表和维度，面向对象接口提供的是具体`Figure`和`Axes`对象的方法。采用这种接口重新创建上面的图表的代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 首先创建两个子图表\n",
    "# 返回值fig是两个子Figure对象，ax是两个子Axes对象\n",
    "fig, ax = plt.subplots(2)\n",
    "\n",
    "# 在两个不同的Axes对象上调用plot方法分别作图\n",
    "ax[0].plot(x, np.sin(x))\n",
    "ax[1].plot(x, np.cos(x));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> For more simple plots, the choice of which style to use is largely a matter of preference, but the object-oriented approach can become a necessity as plots become more complicated.\n",
    "Throughout this chapter, we will switch between the MATLAB-style and object-oriented interfaces, depending on what is most convenient.\n",
    "In most cases, the difference is as small as switching ``plt.plot()`` to ``ax.plot()``, but there are a few gotchas that we will highlight as they come up in the following sections.\n",
    "\n",
    "对于简单的图表来说，采用哪种风格的接口作图取决于个人喜好，但是对于复杂的图表来说，面向对象接口是必须的。在本章中，我们会在两者之间进行切换，依据哪样方式更加方便来决定。在大多数情况下，`plt.plot()`切换到`ax.plot()`之间的区别会很小，但是里面会有些坑，我们会在后续小节中着重指出。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [更多资源](03.13-Further-Resources.ipynb) | [目录](Index.ipynb) | [简单的折线图](04.01-Simple-Line-Plots.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/04.00-Introduction-To-Matplotlib.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
